home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DClap / DFile.cpp < prev    next >
Encoding:
Text File  |  1996-07-05  |  13.9 KB  |  699 lines  |  [TEXT/R*ch]
  1. // DFile.cp
  2.  
  3.  
  4. #include <ncbi.h>
  5. #include <dgg.h>
  6. #include "DFile.h"
  7. #include "Dvibrant.h"
  8. #include "DId.h"
  9. #include <stdio.h>
  10.  
  11. #define NAMESTORE 
  12.  
  13. #if defined(COMP_CWI) || defined(OS_NT)
  14. #define WIN32 
  15. #undef FAR
  16. #undef NEAR
  17. #include <windows.h>
  18. #include <mapiwin.h>
  19.  
  20. #elif defined(OS_DOS)
  21. #include <dir.h>
  22. #include <dos.h>
  23. #endif
  24.  
  25. // class DFileManager
  26. // made into all static methods, Dec94
  27.  
  28. DFileManager*        gFileManager = NULL;
  29.  
  30. const char* DFileManager::kUntitled = "Untitled";
  31.  
  32. char    DFileManager::fName[640];
  33.  
  34.  
  35. void DFileManager::SetFilename( const char* name) 
  36. {
  37.     if (name) StrNCpy( fName, name, 512); else fName[0]= '\0';
  38. }
  39.  
  40. const char* DFileManager::GetInputFileName( const char* extension,  const char* mactype)
  41. {
  42.     Boolean okay= Nlm_GetInputFileName( (char*)fName, 512, (char*)extension, (char*)mactype);
  43.     if (okay) return fName;
  44.     else return NULL;
  45. }
  46.  
  47. const char* DFileManager::GetOutputFileName( const char* defaultname) 
  48. {
  49.     Boolean okay=  Nlm_GetOutputFileName( (char*)fName, 512, (char*)defaultname);
  50.     if (okay) return fName;
  51.     else return NULL;
  52. }
  53.  
  54. const char* DFileManager::GetFolderName()
  55. {
  56.     // this is a quick hack -- currently this selects a file w/in a folder,
  57.     // then chops filename off -- confusing to users, need folder select dialog
  58.     Boolean okay= Nlm_GetInputFileName( (char*)fName, 512, NULL, NULL);
  59.     if (okay) return DFileManager::PathOnlyFromPath(fName);
  60.     else return NULL;
  61. }
  62.     
  63. const char* DFileManager::GetProgramPath()
  64. {
  65.     Nlm_ProgramPath( (char*)fName, 512);
  66.     return fName;
  67. }
  68.  
  69. const char* DFileManager::FilenameFromPath( const char* pathname)
  70. {
  71.     return Nlm_FileNameFind( (char*)pathname);         
  72. }
  73.  
  74. const char* DFileManager::PathOnlyFromPath( const char* pathname)
  75. {
  76.     char* nameonly= Nlm_FileNameFind( (char*)pathname);
  77.     long len= StrLen(pathname) - StrLen(nameonly);
  78.     StrNCpy(fName, pathname, len);
  79.     fName[len]= 0;
  80.     return fName;
  81. }
  82.  
  83.  
  84.  
  85. short DFileManager::FileOrFolderExists( const char* pathname)
  86. {
  87.  
  88. #ifdef OS_MAC
  89.     long    theDirID;
  90.     Boolean isFolder = false;
  91.     char    namebuf[256];
  92.     
  93.     StrNCpy(namebuf, pathname, sizeof(namebuf));
  94.     Nlm_CtoPstr( namebuf);
  95.     short err= GetDirID( 0, 0, namebuf, &theDirID, &isFolder);
  96.     if (err == 0) {
  97.         if (isFolder) return kIsFolder;
  98.         else return kIsFile;
  99.         }
  100.     else return kNothing;
  101. #endif
  102.     
  103. #ifdef OS_UNIX
  104.     struct stat    statbuf;
  105.   if (! stat( pathname, &statbuf)) {
  106.         if ( S_ISDIR(statbuf.st_mode)) return kIsFolder;
  107.         else return kIsFile;
  108.         }
  109.     else return kNothing;
  110. #endif
  111.  
  112. #if defined(COMP_CWI) || defined(OS_NT)
  113.     WIN32_FIND_DATA finfo;
  114.     HANDLE hFindFile;
  115.     
  116.   MemFill( &finfo, 0, sizeof(finfo));
  117.   finfo.dwFileAttributes= 
  118.       FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_NORMAL;
  119.     hFindFile= FindFirstFile( (char*)pathname, &finfo);
  120.     if (hFindFile!=0) {
  121.         (void) FindClose(hFindFile);
  122.         if ( finfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) return kIsFolder;
  123.         else return kIsFile;
  124.         }
  125.     else return kNothing;
  126.     
  127. #elif defined(OS_DOS)
  128. #if defined(COMP_SYMC)
  129.   FIND* finfo= findfirst( pathname, FA_RDONLY | FA_DIREC);
  130.   if (finfo) {
  131.         if ( finfo->attribute & FA_DIREC) return kIsFolder;
  132.         else return kIsFile;
  133.     }
  134. #else
  135.     struct  ffblk  finfo;
  136.     
  137.   MemFill( &finfo, 0, sizeof(finfo));
  138.     short err= findfirst( pathname, &finfo, FA_RDONLY | FA_DIREC);
  139.     if (err==0) {
  140.         if ( finfo.ff_attrib & FA_DIREC) return kIsFolder;
  141.         else return kIsFile;
  142.         }
  143.     else return kNothing;
  144. #endif
  145. #endif
  146.  
  147. // for others...
  148.     return FileExists( pathname);
  149. }
  150.  
  151.  
  152. Boolean DFileManager::FileExists( const char* pathname)
  153. {
  154.     FILE* aFile= Nlm_FileOpen( (char*)pathname, "r");
  155.     if (aFile) {
  156.         Nlm_FileClose( aFile);
  157.         return true;
  158.         }
  159.     else
  160.         return false;
  161. }
  162.  
  163. Boolean DFileManager::Rename( const char* pathname, const char* newpathname)
  164. {
  165.         return Nlm_FileRename((char*)pathname, (char*)newpathname);
  166. }
  167.  
  168. Boolean DFileManager::IsRelativePath(const char* path)
  169. {
  170.     char* lpath= (char*) path;
  171.     
  172.     if (!lpath || !*lpath) return false;
  173.     
  174. #ifdef OS_MAC
  175.     return (*lpath == ':');
  176. #endif
  177.  
  178. #if defined(OS_DOS) || defined (OS_NT)
  179.     if (*lpath == '\\' || lpath[1] == ':') return false;
  180.     else return true;
  181. #endif
  182.  
  183. #ifdef OS_UNIX
  184.     return (*lpath != '/');
  185. #endif
  186.  
  187. #ifdef OS_VMS
  188.     // [some.path]file.name
  189.     // [-]file.name
  190.     // disk:[path.to.somewhere]file.name
  191.     if (StrChr(lpath,':') != 0) return false;
  192.     else {
  193.         char* cp= StrChr(lpath,'[');
  194.         if (!cp) return true;
  195.         else if (cp[1] == '.' || cp[1] == '-') return true;
  196.         else return false;
  197.         }
  198. #endif
  199.     return false;
  200. }
  201.  
  202.  
  203. char*    DFileManager::TempFolder( char* namestore)
  204. {
  205.     char* path;
  206.     if (!namestore) namestore= fName;
  207.     *namestore= 0;
  208.     
  209. #ifdef OS_MAC
  210.     path= Nlm_TmpNam(namestore); // uses FindFolder(kOnSystemDisk, kTemporaryFolderType ..
  211.     if (path) {
  212.         char* nameonly= Nlm_FileNameFind( path);
  213.         long len= StrLen(path) - StrLen(nameonly);
  214.         if (len > 512) len= 512;
  215.         StrNCpy( namestore, path, len);    
  216.         namestore[len]= 0;
  217.         }
  218. #endif
  219.  
  220. #if (defined(OS_UNIX) || defined(OS_DOS) || defined (OS_NT) || defined(OS_VMS))
  221.     path= getenv("TMPDIR");
  222.     if (!path) path= getenv("TMP");
  223.     if (!path) path= getenv("TEMP");
  224. #ifdef OS_UNIX
  225.     if (!path) path= "/tmp";
  226. #endif
  227.     if (path) StrNCpy( namestore, path, 512);
  228. #endif
  229.  
  230.     return namestore;
  231. }
  232.  
  233.  
  234. char*    DFileManager::TempFilename( char* namestore)
  235. {
  236.     return Nlm_TmpNam( namestore);
  237. }
  238.  
  239. char*    DFileManager::TempFilenameonly( char* namestore)
  240. {
  241.     char * nameonly, * path;
  242.     if (!namestore) namestore= fName;
  243.     *namestore= 0;
  244.     
  245.     path= Nlm_TmpNam( namestore);
  246.     if (path) {
  247.         nameonly= Nlm_FileNameFind( path);
  248.         if (nameonly) StrCpy( namestore, nameonly);    
  249.         return namestore;
  250.         }
  251.     else
  252.         return path;
  253. }
  254.         
  255. Boolean DFileManager::CreateFolder( const char* pathname)
  256. {
  257.     return Nlm_CreateDir( (char*) pathname);
  258. }
  259.  
  260.  
  261.  
  262. const char* DFileManager::BuildPath(const char* rootpath, const char* subfolder, const char* filename)
  263. {
  264.     if (rootpath) StrNCpy(fName, rootpath, 256);
  265.     else fName[0]= 0;
  266.     return Nlm_FileBuildPath(fName, (char*) subfolder, (char*) filename);
  267. }
  268.  
  269.  
  270. void DFileManager::UnixToLocalPath(char*& pathname)
  271. {
  272.     if (!pathname || !*pathname) return;
  273. #ifndef OS_UNIX
  274. #ifdef OS_VMS
  275.     // can't handle this yet .. can stdio calls under vms translate unix/style/paths?
  276. #else
  277. #ifdef OS_MAC
  278.     char buf[512], *np = buf, c;
  279.     char* cp= pathname;
  280.     long  n = 0;
  281.     
  282.     if (*cp == '/') cp++;         // absolute: start at 1st pathname
  283.     else { *np++= DIRDELIMCHR; n++; }     // relative: must insert DIRDEL before start !
  284.     do {
  285.         c= *cp++;
  286.         if (c == '/') c= DIRDELIMCHR;
  287.         *np++ = c; 
  288.         n++;
  289.     } while (c);
  290.     MemCpy(pathname, buf, n); // risky !!
  291.  
  292. #else
  293.     // MDOS, other?
  294.     char* cp= pathname;
  295.     do {
  296.         cp= StrChr( cp, '/');
  297.         if (cp) *cp++= DIRDELIMCHR; 
  298.     } while (cp);
  299. #endif
  300. #endif
  301. #endif
  302. }
  303.  
  304. const char* DFileManager::FileSuffix(const char* pathname)
  305. {
  306.   long     len = StrLen(pathname);
  307.   char* cp = (char*)pathname + len;
  308.   while (cp > pathname && *cp != DIRDELIMCHR) {
  309.         if (*cp == '.') return cp;
  310.         cp--;
  311.       }
  312.   return NULL;
  313. }
  314.  
  315.  
  316. void DFileManager::ReplaceSuffix(char* filename, long maxname, const char* suffix)
  317. {
  318.     long curlen, newlen;
  319.     char* psuf= (char*)FileSuffix(filename);
  320.     if (suffix) newlen= StrLen(suffix) + 1;
  321.   else newlen= 0;
  322.     if (psuf) {
  323.         curlen= StrLen(filename) - StrLen(psuf);
  324.         if (newlen > maxname - curlen) newlen= maxname - curlen;
  325.         if (suffix) StrNCpy( psuf, suffix, newlen);
  326.         else *psuf= 0;
  327.         }
  328.     else if (suffix) {
  329.         curlen= StrLen(filename);
  330.         if (newlen > maxname - curlen) newlen= maxname - curlen;
  331.         if (suffix) StrNCat( filename, suffix, newlen);
  332.         }
  333. }
  334.  
  335.  
  336.  
  337.  
  338.  
  339. //class DFile : public DObject
  340.  
  341.  
  342. char* DFile::fgType = NULL;
  343. char* DFile::fgSire = NULL;
  344.     
  345. DFile::DFile() 
  346. {
  347.     fFile= NULL;
  348.     fName= NULL;
  349.     fUseNameStore= false;
  350.     fMode= StrDup("r");
  351.     fType= fgType;
  352.     fSire= fgSire;
  353.     fEof= true;
  354. }
  355.  
  356.     
  357. DFile::DFile(const char* filename, const char* openmode,  
  358.                         const char* type, const char* creator)
  359. {
  360.     fFile= NULL;
  361.     fName= NULL;
  362.     fUseNameStore= false;
  363.     fMode= NULL;
  364.     fType= fgType;
  365.     fSire= fgSire;
  366.     fEof= true;
  367.     Initialize( filename, openmode, type, creator);
  368. }
  369.  
  370. void DFile::Initialize(const char* filename, const char* openmode,
  371.                         const char* type, const char* creator)
  372. {
  373.     char * name, * mode;
  374.     
  375.     if (fFile) Close(); 
  376. #ifdef NAMESTORE
  377.     Boolean freeName= (!fUseNameStore);
  378.     if (!filename) { 
  379.         fUseNameStore= true; 
  380.         *fNameStore= 0;
  381.         name= fNameStore; 
  382.         }
  383.     else {
  384.         fUseNameStore= (StrLen((char*) filename) < sizeof(fNameStore));
  385.         if (fUseNameStore) {
  386.             StrCpy(fNameStore, (char*) filename);
  387.             name= fNameStore;
  388.             }
  389.         else {
  390.             name= StrDup( (char*) filename); // do before free in case these are some of self's data
  391.             }
  392.         }
  393.     if (freeName) MemFree(fName);
  394.     fName= name;
  395. #else
  396.     name= StrDup( (char*) filename); // do before free in case these are some of self's data
  397.     MemFree(fName);
  398.     fName= name;
  399. #endif
  400.  
  401.     mode= StrDup( (char*) openmode);
  402.     MemFree(fMode);
  403.     fMode= mode;
  404.     
  405.     fType= (char*)type;
  406.     fSire= (char*)creator;
  407.     if (!fType) fType= fgType;
  408.     if (!fSire) fSire= fgSire;
  409.     fEof= true;
  410. }
  411.     
  412. DFile::~DFile() 
  413. {
  414.     if (fFile) Close();
  415. #ifdef NAMESTORE
  416.     if (!fUseNameStore) 
  417. #endif
  418.         MemFree(fName);
  419.     MemFree( fMode);
  420. }
  421.  
  422. Boolean DFile::suicide(void) 
  423. { 
  424.     if (GetOwnerCount() <= 1) { 
  425.         delete this; 
  426.         return true; 
  427.         }
  428.     else 
  429.         return DObject::suicide();
  430. }
  431.  
  432. Boolean DFile::suicide(short ownercount)
  433. {
  434.     if (ownercount < 1) {
  435.         delete this; 
  436.         return true; 
  437.         }
  438.     else 
  439.         return DObject::suicide(ownercount);
  440. }
  441.  
  442. Boolean DFile::Exists()
  443. {
  444.     if (fFile) return true; // this is only around if file exists
  445.     else if (!fName) return false;
  446.     else {
  447.         short kind= DFileManager::FileOrFolderExists(fName);
  448.         if (kind == DFileManager::kIsFile) return true;
  449.         else if (kind == DFileManager::kIsFolder) return false; //?? what to do?? false or true?
  450.         else return DFileManager::FileExists(fName); // try another test?
  451.         }
  452. }
  453.  
  454. void DFile::Create(const char* filetype, const char* creator)
  455. {
  456.     // this doesn't delete existing file...! on MacOS
  457.     fType= (char*)filetype;
  458.     fSire= (char*)creator;
  459. #ifndef OS_MAC
  460.  if (! DFileManager::FileExists(fName))
  461. #endif
  462.     Nlm_FileCreate(fName, (char*)filetype, (char*)creator);
  463. }
  464.  
  465. Boolean DFile::Delete()
  466. {
  467.     Close();
  468.     return Nlm_FileRemove(fName);
  469. }
  470.  
  471.  
  472. void DFile::SetName(const char* newname)
  473. {
  474.     if (newname && *newname && StrCmp(newname, fName)!=0) {
  475.         Close();
  476. #ifdef NAMESTORE
  477.         if (!fUseNameStore) MemFree(fName);
  478.         fUseNameStore= (StrLen((char*) newname) < sizeof(fNameStore));
  479.         if (fUseNameStore) {
  480.             StrCpy(fNameStore, (char*) newname);
  481.             fName= fNameStore;
  482.             }
  483.         else {
  484.             fName= StrDup( (char*) newname); 
  485.             }
  486. #else
  487.         MemFree(fName);
  488.         fName= StrDup( (char*) newname); 
  489. #endif
  490.     }
  491. }
  492.  
  493.  
  494. Boolean DFile::Rename(const char* newname)
  495. {
  496.     Boolean okay= false;
  497.     if (newname && *newname && StrCmp(newname, fName)!=0) {
  498.         okay= Nlm_FileRename(fName, (char*)newname);
  499.         if (okay) SetName( newname);
  500.         }
  501.     return okay;
  502. }
  503.  
  504.  
  505. void DFile::SetMode(const char* openmode)
  506. {
  507.     if (openmode && StringCmp(openmode, fMode) != 0) {
  508.         Nlm_FileClose( fFile);
  509.         char* mode= StrDup( (char*) openmode);
  510.         MemFree(fMode);
  511.         fMode= mode;
  512.         }
  513. }
  514.  
  515.         // result in all funcs here is error code or 0
  516. short DFile::Open(const char* openmode)
  517. {
  518.     if (openmode) {
  519.         if (StringCmp(openmode, fMode) == 0) 
  520.             openmode= NULL;
  521.         else {
  522.             char* mode= StrDup( (char*) openmode);
  523.             if (fMode) MemFree(fMode);
  524.             fMode= mode;
  525.             }
  526.         }
  527.     if (fFile) 
  528.         if (openmode) {
  529.             Nlm_FileClose( fFile);
  530.             fFile= Nlm_FileOpen(fName, fMode);
  531.             }
  532.         else fseek(fFile, 0, 0); // reset
  533.     else {
  534.         if ((fSire || fType) && (*fMode == 'w' || *fMode == 'a'))
  535.             Create( fType, fSire);
  536.         fFile= Nlm_FileOpen(fName, fMode);
  537.         }
  538.     fEof= (fFile == NULL);
  539.     return (fFile) ? 0 : -1;
  540. }
  541.  
  542.  
  543. short DFile::Close()
  544. {
  545.     if (fFile) Nlm_FileClose( fFile);
  546.     fEof= true;
  547.     fFile= NULL;
  548.     return 0;
  549. }
  550.  
  551. short DFile::GetDataLength(ulong& filelen)
  552. {
  553.     filelen= Nlm_FileLength(fName);
  554.     return 0; // any error code is trapped in Nlm_
  555. }
  556.  
  557. short DFile::GetDataMark(ulong& fileindex)
  558. {
  559.     // not yet available in ncbi toolkit...
  560.     short err= 0;
  561.     fileindex= 0;
  562.     if (!fFile) return -1;
  563.     long findex= ftell(fFile);
  564.     if (findex<0) {
  565.         err= findex;
  566.         fileindex= 0;
  567.         }
  568.     else
  569.         fileindex= findex;
  570.     return err;
  571. }
  572.  
  573. short DFile::SetDataMark(ulong    fileindex)
  574. {
  575.             // not yet available in ncbi toolkit...
  576.     if (!fFile) return -1;
  577.     else return fseek(fFile, fileindex, 0);
  578. }
  579.  
  580.  
  581. Boolean DFile::EndOfFile()
  582. {
  583.     if (!fFile) return -1;
  584.     else {
  585.         if (!fEof) fEof= feof(fFile); // !! need this !! this isn't always RIGHT !!
  586.         return fEof;
  587.         }
  588. }
  589.  
  590. short DFile::GetFileType(long& fileType) 
  591. {
  592.         // this is a silly hack -- needs work?
  593.     if (fMode && strchr(fMode,'t')) fileType= cTEXT;
  594.     else fileType= 0;
  595.     return 0;
  596. }
  597.  
  598. short DFile::ReadData( void* buffer, ulong& count) 
  599. {
  600.     long newcount= Nlm_FileRead(buffer, 1, count, fFile);
  601.     if (newcount == count) return 0;
  602.     else { 
  603.         if (newcount==0) fEof= true;
  604.         count= newcount; 
  605.         return -1; 
  606.         } 
  607. }
  608.  
  609. short DFile::ReadLine( char* line, ulong count) 
  610. {
  611.     void *buf= Nlm_FileGets(line, count, fFile);
  612.     if (buf) return 0;
  613.     else {
  614.         fEof= true;
  615.         return -1;
  616.         }
  617. }
  618.  
  619.  
  620. short DFile::ReadUntil( void* buffer, ulong& count, char stopchar) 
  621. {
  622.                 // no ncbi proc for this...
  623.     register int    c;
  624.     register char* bp = (char*) buffer;
  625.     long maxcount= count;
  626.  
  627.     if (!fFile || !buffer) return -1;
  628.     count= 0;
  629.     while (true) {
  630.         c = fgetc( fFile);
  631.         if (c<0) {
  632.             //if (c == EOF) 
  633.             fEof= true;
  634.             return c;
  635.             }
  636.         else {
  637.             *bp++= c;
  638.             count++;
  639.             if (c == stopchar || count >= maxcount)  
  640.                 return 0; // ?? do we stuff stopchar into buffer?
  641.             }
  642.         }
  643.     return 0;
  644. }
  645.  
  646.  
  647. short DFile::WriteLine( char* line, Boolean addNewline) 
  648. {
  649.     short result;
  650.     result= Nlm_FilePuts( line, fFile);
  651.     if (addNewline) result += Nlm_FilePuts( LineEnd, fFile);
  652.     return result;
  653. }
  654.  
  655. short DFile::WriteData( void* buffer, ulong& count)
  656. {
  657.     ulong newcount= Nlm_FileWrite(buffer, 1, count, fFile);
  658.     if (count != newcount) { count= newcount; return -1; } //??
  659.     else return 0;
  660. }
  661.  
  662.  
  663.  
  664. // class DTempFile
  665.  
  666. DTempFile::DTempFile() : 
  667.     DFile()
  668. {
  669.     // ?? text/binary mode flag
  670.     char    namestore[512];
  671.     Initialize( gFileManager->TempFilename(namestore), "a", NULL, NULL);
  672.     Open();
  673. }
  674.     
  675. DTempFile::~DTempFile()
  676. {
  677.     Delete();
  678. }    
  679.  
  680. char* DTempFile::ReadIntoMemory(ulong& bytesread, Boolean deleteAfterRead)
  681. {
  682.     short     err;
  683.     ulong    count;
  684.     char    * data;
  685.     
  686.     Open("r");
  687.     err= GetDataLength( count);
  688.     data= (char*) MemNew( count+1);
  689.     if (data) {
  690.         err= ReadData( data, count);
  691.         bytesread= count;
  692.         data[count]= 0; // add null term
  693.         }
  694.     Close();
  695.     if (deleteAfterRead) Delete();
  696.     return data;
  697. }
  698.  
  699.